home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Telnet 2.6.1d1 / src / source / vr / vrrgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-21  |  9.5 KB  |  403 lines  |  [TEXT/KAHL]
  1. /*
  2.  *
  3.  *      Virtual Graphics Kernel Macintosh Real Graphics Interface
  4.  *                          (rgmac.c)
  5.  *
  6.  *   National Center for Supercomputing Applications
  7.  *      by Gaige B. Paulsen
  8.  *
  9.  *    This file contains the macintosh real screen calls for the NCSA
  10.  *  Virtual Graphics Kernel.
  11.  *
  12.  *    Following are the Per Device calls:
  13.  *
  14.  *   MacRGraster( p,x1,y1,x2,y2,wid)- Plot raster in rect @(x1,y1,x2,y2) with wid @ p
  15.  *   MacRGcopy( x1,y1,x2,y2,x3,y3,x4,y4)- 
  16.  *   MacRGmap( offset,count,data)   - 
  17.  *
  18.  *
  19.  *  WARNING, WARNING!
  20.  *  Gaige has this cute idea about how to do "subwindows" of real windows by shifting
  21.  *  the window number by 4 bits (MAC_WINDOW_SHIFT).  Then, the remainder is the
  22.  *  sub-window number.  It will probably work, but you MUST keep the shifted and
  23.  *  non-shifted numbers straight.  For example, MacRGdestroy() and MacRGremove() take
  24.  *  different uses of the window number right now.  
  25.  *
  26.  *
  27.  *  Macintosh only Routines:
  28.  *
  29.  *      Version Date    Notes
  30.  *      ------- ------  ---------------------------------------------------
  31.  *        0.5     880912    Initial Coding -GBP
  32.  *      1.0     890216  Minor fixes for 1.0 - TKK
  33.  */
  34.  
  35. #ifdef MPW
  36. #pragma segment ICR
  37. #endif
  38.  
  39. #include "TelnetHeader.h"
  40.  
  41. #define __ALLNU__
  42. #include <Palettes.h>
  43. #include <Scrap.h>
  44.  
  45. #include <stdio.h>
  46. #include <string.h>
  47.  
  48. #include "maclook.proto.h"
  49. #include "vdevice.h"
  50. #include "vr.h"
  51. #include "InternalEvents.h"
  52. #include "telneterrors.h"
  53. #include "debug.h"
  54.  
  55. #define MAX_MAC_RGS    8
  56. #define MAX_MAC_SUB 16
  57. #define MAC_WINDOW_SHIFT    4        /* Bits shifted */
  58. #define    MAC_SUB_MASK    0xf            /* Bits maksed */
  59.  
  60. #include "vrrgmac.proto.h"
  61.  
  62. extern char *tempspot;
  63.  
  64. typedef struct MacWindow {
  65.     VDevice            vdev;            /* virtual device to draw in, has its own colors */
  66.     WindowPtr         window;            /* My Window  (0L if not in use ) */
  67.     PaletteHandle     palette;        /* My Palette */
  68.     char            title[256];        /* Title string */
  69.     
  70.     
  71.     Point            size;            /* My height and width */
  72.     Rect            subs[MAX_MAC_SUB];/* Rectangles of my subwindows [0,0,0,0] if not in use */
  73.     } MacWindow;
  74.  
  75. MacWindow *MacRGs;
  76.  
  77. short RGwn=0;                            /* Window number in use */
  78. short RGsub=0;                        /* Sub-Window Number in use */
  79.  
  80. void MacRGinit(void)
  81. {
  82.     short i;
  83.     
  84.     MacRGs= (MacWindow *)NewPtr( MAX_MAC_RGS * sizeof(MacWindow));
  85.     for (i=0;i<MAX_MAC_RGS;i++)
  86.         MacRGs[i].window=NULL;
  87. }
  88.  
  89. /************************************************************
  90.  * MacRGnewwindow( name, x1, y1, x2, y2)        -            *
  91.  *        make a new subwindow to wn                            *
  92.  ************************************************************/
  93.  
  94. short MacRGnewwindow
  95.   (
  96.     char *name,
  97.     short x1,
  98.     short y1,
  99.     short x2,
  100.     short y2
  101.   )
  102. {
  103.     short w,i ;
  104.     extern short RScolor;
  105.     Rect wDims;
  106.     register char *p;
  107.     RGBColor curcol;
  108.  
  109.     p = (char *)NewPtr(1000 + (x2-x1+5) *(y2-y1+5));
  110.     if (!p)         /* is there enough memory??? */
  111.         {            /* no memory, so let us know about it */
  112.         DoError(108 | MEMORY_ERRORCLASS, LEVEL2, NULL);        
  113.         return(-1);
  114.         }
  115.     else
  116.         DisposPtr(p);
  117.     
  118.     for (w=0; w<MAX_MAC_RGS && MacRGs[w].window; w++);
  119.     
  120.     if (w>= MAX_MAC_RGS)
  121.         return( -1);
  122.         
  123.     if ((x2 - x1) & 1)                        /* odd width, must be even */
  124.         x2++;
  125.     
  126.     SetRect( &wDims,  x1+40, y1+40, x2+40, y2+40);
  127.         
  128.     strcpy( MacRGs[w].title, name);                        /* Copy of the name */
  129.     
  130.     if (!RScolor)        /* Borrow from RS */
  131.         return(-1);
  132. /*        MacRGs[w].window=NewWindow(0L, &wDims, name, TRUE, 4, -1L, TRUE, (long) w); */
  133.     else {
  134.         short i;
  135.         Str255    scratchPstring;
  136.         strcpy((char *)scratchPstring, name);
  137.         CtoPstr((char *)scratchPstring);
  138.         
  139.         MacRGs[w].window=NewCWindow(NULL, &wDims, scratchPstring, TRUE, noGrowDocProc, kInFront,    /* BYU LSC */
  140.             TRUE, (long) w);
  141.  
  142.  
  143.         MacRGs[w].vdev.bp  = (unsigned char *)NewPtr( (x2-x1+5) *(y2-y1+5));    /* BYU LSC */
  144.  
  145.         if (!MacRGs[w].vdev.bp) putln("Window has no bitmap...");
  146.         else {
  147.             SetRect(&MacRGs[w].vdev.bounds, 0,0, x2-x1, y2-y1);
  148.             InitVDevice(&MacRGs[w].vdev);        /* get vdevice going */
  149.         
  150.             MacRGs[w].palette = NewPalette( 256, NULL, pmTolerant, 0);
  151.             
  152.             for (i=0; i<256; i++) {                /* load with grey-scale */
  153.                 curcol.red = i<<8;
  154.                 curcol.green = i<<8;
  155.                 curcol.blue = i<<8;
  156.                 SetEntryColor( MacRGs[w].palette, i, &curcol);
  157.                 }
  158.             
  159.             SetPalette( MacRGs[w].window, MacRGs[w].palette, TRUE);
  160.             ActivatePalette( MacRGs[w].window);
  161.         
  162.             ColorVDevice(&MacRGs[w].vdev,MacRGs[w].palette);
  163.             }
  164.         }
  165.     
  166.  
  167.     if (!MacRGs[w].window)         /* couldnt open the real window */
  168.         {
  169.         DoError (302 | RESOURCE_ERRORCLASS, LEVEL2, NULL);
  170.         return(-2);
  171.         }
  172.     
  173.     ((WindowPeek)MacRGs[w].window)->windowKind = WIN_ICRG;    
  174.     MacRGs[w].size.h = x2-x1;
  175.     MacRGs[w].size.v = y2-y1;
  176.     for (i=0; i<MAX_MAC_SUB; i++)
  177.         SetRect( &MacRGs[w].subs[i], 0,0,0,0);            /* Reset the subs */
  178.     RGwn = w;
  179.     RGsub= 0;
  180.     return (w << MAC_WINDOW_SHIFT);
  181. }
  182.  
  183. /****************************************
  184.  * MacRGsubwindow(wn)        -            *
  185.  *        make a new subwindow to wn        *
  186.  ****************************************/
  187.  
  188. short MacRGsubwindow( short wn)
  189. {
  190.     return (wn);
  191. }
  192.  
  193. /****************************************
  194.  * MacRGsetwindow(wn)        -            *
  195.  *        set the drawing window to wn    *
  196.  ****************************************/
  197. void MacRGsetwindow( short wn)
  198. {
  199.     short w = wn >> MAC_WINDOW_SHIFT;
  200.     
  201.     if (!MacRGs[w].window)
  202.         return;
  203.     
  204.     SetPort( MacRGs[w].window);
  205.     RGwn = w;
  206.     RGsub= wn & MAC_SUB_MASK;
  207.     
  208.     /* Optionally set the clip region */
  209. }
  210.  
  211. /****************************************
  212.  * MacRGdestroy(wn)        -                *
  213.  *        destroy window wn                *
  214.  ****************************************/
  215. void MacRGdestroy(short wn)
  216. {
  217.     
  218. //    sprintf((char *) tempspot,"destroy: %d", wn); putln((char *) tempspot);    /* BYU LSC */
  219.     if (!MacRGs[wn].window)
  220.         return;
  221.     
  222.     VRdestroybyName((char *) &MacRGs[wn].title);
  223. }
  224.     
  225. /****************************************
  226.  * MacRGremove(wn)        -                *
  227.  *        destroy window wn                *
  228.  ****************************************/
  229. void MacRGremove
  230.   (
  231.     short wn
  232.   )
  233. {
  234.     CGrafPtr cgp;
  235.     short w = wn>> MAC_WINDOW_SHIFT;
  236.     
  237.     if (!MacRGs[w].window)
  238.         return;
  239.     
  240.     TrashVDevice(&MacRGs[w].vdev);
  241.     
  242.     if (MacRGs[w].vdev.bp) 
  243.         DisposPtr((Ptr)MacRGs[w].vdev.bp);
  244.     
  245.     cgp = (CGrafPtr) MacRGs[w].window;                    /* unseed window color table */
  246.     (*(*(cgp->portPixMap))->pmTable)->ctSeed = GetCTSeed();
  247.     
  248.     DisposeWindow( MacRGs[w].window);        /* Get rid of the actual window */
  249.  
  250.     if (MacRGs[w].palette)
  251.         DisposePalette( MacRGs[w].palette);
  252.         
  253.     MacRGs[w].palette = NULL;
  254.     MacRGs[w].window = NULL;
  255. //    sprintf((char *) tempspot,"take away: %d", w); putln((char *) tempspot);    /* BYU LSC */
  256. }
  257.  
  258. short MacRGfindwind(WindowPtr wind)
  259. {
  260.     short i=0;
  261.     
  262.     if (!wind)
  263.         return(-2);
  264.     
  265.     while (i<MAX_MAC_RGS && wind != MacRGs[i].window)
  266.         i++;
  267.     if (i==MAX_MAC_RGS)
  268.         return(-1);
  269.  
  270.     return( i);
  271. }
  272.  
  273. /************************************************************************************/
  274. /* MacRGcopy
  275. *  Copybits the image window into the clipboard.
  276. *  
  277. */
  278. RGBColor    icrwhite = { 0xffff,0xffff,0xffff },
  279.             icrblack = { 0,0,0}; 
  280.             
  281. void MacRGcopy(WindowPtr wind)
  282. {
  283.     Rect copysize,copyfrom;
  284.     long len,wn;
  285.     PicHandle picture;
  286.     CGrafPtr hidep;
  287.         
  288.     if (( wn= MacRGfindwind( wind)) <0)
  289.         return;                        /* Couldn't do it */
  290.  
  291.     hidep = &MacRGs[wn].vdev.vport;
  292.     copyfrom = MacRGs[wn].vdev.bounds;
  293.             
  294.     SetPort(wind);
  295.     
  296.     copysize = copyfrom;                        /* boundary of drawing area */
  297.  
  298.     picture= OpenPicture(©size);
  299.  
  300.     ClipRect(©size);
  301.     
  302. /*    RGBBackColor(&icrwhite);
  303.     RGBForeColor(&icrblack); */
  304.  
  305.     ForeColor( blackColor);
  306.     BackColor( whiteColor);
  307.     HLock((Handle) hidep->portPixMap);
  308.                 
  309.     CopyBits((BitMap *) (*(hidep->portPixMap)), &wind->portBits,
  310.             ©from, ©size, srcCopy, NULL); 
  311.             
  312.     HUnlock((Handle) hidep->portPixMap);
  313.  
  314.     ClosePicture();
  315.     
  316. /*    put the PICT into the scrap manager */
  317.     len = GetHandleSize((Handle) picture);
  318.     HLock((Handle) picture);
  319.     ZeroScrap();
  320.     PutScrap( len, 'PICT', (Ptr) *picture);
  321.     HUnlock((Handle) picture);
  322.     KillPicture(picture);
  323.  
  324. }
  325.  
  326. short MacRGupdate( WindowPtr wind)
  327. {
  328.     short wn;
  329.     Rect cbRect;
  330.     
  331.     if (( wn= MacRGfindwind( wind)) <0)
  332.         return(-1);                        /* Couldn't do it */
  333.  
  334.      SetPort(wind);
  335.     ForeColor( blackColor);
  336.     BackColor( whiteColor);
  337.     BeginUpdate(wind);
  338.         /* EraseRect( &wind->portRect); */
  339.         HLock((Handle) MacRGs[wn].vdev.vport.portPixMap);
  340.         cbRect = MacRGs[wn].vdev.bounds;
  341.         CopyBits((BitMap *) *MacRGs[wn].vdev.vport.portPixMap,&(wind->portBits), 
  342.             &cbRect,&cbRect, srcCopy, NULL);
  343.         HUnlock((Handle) MacRGs[wn].vdev.vport.portPixMap);
  344.     EndUpdate( wind);
  345.     return(0);
  346. }
  347.  
  348. /**************************** Hereafter lie the graphics routines ************************/
  349. short    MacRGraster(char *data, short x1, short y1, short x2, short y2, short rowbytes)
  350. {
  351.     Rect tr;
  352.     register char *p;
  353.     register short i;
  354.     
  355.     if (!MacRGs[RGwn].window)
  356.         return(-1);
  357.         
  358.     SetPort( MacRGs[ RGwn].window);
  359.     
  360.     if (MacRGs[RGwn].vdev.bp) {                /* If we have off-screen buffer */
  361.  
  362.         p = (char *) MacRGs[RGwn].vdev.bp + MacRGs[RGwn].size.h*y1 + x1;  /* start point */
  363.         for (i=0; i<rowbytes; i++)
  364.             *p++ = *data++;
  365.  
  366.         SetRect(&tr, x1,y1, x2+1,y2+1);
  367.         InvalRect(&tr);
  368.     }
  369.     
  370.     return(0);
  371. }
  372.  
  373. short    MacRGcopyrgn(short x1, short y1, short x2, short y2, short x3, short y3, short x4, short y4)
  374. {
  375. #pragma unused(x1, y1, x2, y2, x3, y3, x4, y4)
  376.     /* copy one region to another within wn */
  377.     return 0;
  378. }
  379.  
  380. short    MacRGmap(short start, short length, char *data)
  381. {
  382.     short i;
  383.     RGBColor curcol;
  384.     
  385.     for (i=start; i<start+length; i++) {        
  386.         curcol.red = (*data++)<<8;
  387.         curcol.green = (*data++)<<8;
  388.         curcol.blue = (*data++)<<8;
  389.         SetEntryColor( MacRGs[RGwn].palette, i, &curcol);
  390.     }
  391.     
  392.     SetPalette( MacRGs[RGwn].window, MacRGs[RGwn].palette, TRUE);
  393.     ActivatePalette( MacRGs[RGwn].window);
  394.  
  395.     ColorVDevice(&MacRGs[RGwn].vdev,MacRGs[RGwn].palette);
  396. #if 0                                                            /* BYU LSC */
  397.     sprintf((char *) tempspot, "Palette[%d,%d]",start,length);    /* BYU LSC */
  398.     putln((char *) tempspot);                                    /* BYU LSC */
  399. #endif
  400.     return 0;
  401. }
  402.         
  403.